home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / mempolicy.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  6KB  |  230 lines
  1. #ifndef _LINUX_MEMPOLICY_H
  2. #define _LINUX_MEMPOLICY_H 1
  3.  
  4. #include <linux/errno.h>
  5.  
  6. /*
  7.  * NUMA memory policies for Linux.
  8.  * Copyright 2003,2004 Andi Kleen SuSE Labs
  9.  */
  10.  
  11. /* Policies */
  12. #define MPOL_DEFAULT    0
  13. #define MPOL_PREFERRED    1
  14. #define MPOL_BIND    2
  15. #define MPOL_INTERLEAVE    3
  16.  
  17. #define MPOL_MAX MPOL_INTERLEAVE
  18.  
  19. /* Flags for get_mem_policy */
  20. #define MPOL_F_NODE    (1<<0)    /* return next IL mode instead of node mask */
  21. #define MPOL_F_ADDR    (1<<1)    /* look up vma using address */
  22.  
  23. /* Flags for mbind */
  24. #define MPOL_MF_STRICT    (1<<0)    /* Verify existing pages in the mapping */
  25.  
  26. #ifdef __KERNEL__
  27.  
  28. #include <linux/config.h>
  29. #include <linux/mmzone.h>
  30. #include <linux/bitmap.h>
  31. #include <linux/slab.h>
  32. #include <linux/rbtree.h>
  33. #include <linux/spinlock.h>
  34.  
  35. struct vm_area_struct;
  36.  
  37. #ifdef CONFIG_NUMA
  38.  
  39. /*
  40.  * Describe a memory policy.
  41.  *
  42.  * A mempolicy can be either associated with a process or with a VMA.
  43.  * For VMA related allocations the VMA policy is preferred, otherwise
  44.  * the process policy is used. Interrupts ignore the memory policy
  45.  * of the current process.
  46.  *
  47.  * Locking policy for interlave:
  48.  * In process context there is no locking because only the process accesses
  49.  * its own state. All vma manipulation is somewhat protected by a down_read on
  50.  * mmap_sem. For allocating in the interleave policy the page_table_lock
  51.  * must be also aquired to protect il_next.
  52.  *
  53.  * Freeing policy:
  54.  * When policy is MPOL_BIND v.zonelist is kmalloc'ed and must be kfree'd.
  55.  * All other policies don't have any external state. mpol_free() handles this.
  56.  *
  57.  * Copying policy objects:
  58.  * For MPOL_BIND the zonelist must be always duplicated. mpol_clone() does this.
  59.  */
  60. struct mempolicy {
  61.     atomic_t refcnt;
  62.     short policy;     /* See MPOL_* above */
  63.     union {
  64.         struct zonelist  *zonelist;    /* bind */
  65.         short          preferred_node; /* preferred */
  66.         DECLARE_BITMAP(nodes, MAX_NUMNODES); /* interleave */
  67.         /* undefined for default */
  68.     } v;
  69. };
  70.  
  71. /*
  72.  * Support for managing mempolicy data objects (clone, copy, destroy)
  73.  * The default fast path of a NULL MPOL_DEFAULT policy is always inlined.
  74.  */
  75.  
  76. extern void __mpol_free(struct mempolicy *pol);
  77. static inline void mpol_free(struct mempolicy *pol)
  78. {
  79.     if (pol)
  80.         __mpol_free(pol);
  81. }
  82.  
  83. extern struct mempolicy *__mpol_copy(struct mempolicy *pol);
  84. static inline struct mempolicy *mpol_copy(struct mempolicy *pol)
  85. {
  86.     if (pol)
  87.         pol = __mpol_copy(pol);
  88.     return pol;
  89. }
  90.  
  91. #define vma_policy(vma) ((vma)->vm_policy)
  92. #define vma_set_policy(vma, pol) ((vma)->vm_policy = (pol))
  93.  
  94. static inline void mpol_get(struct mempolicy *pol)
  95. {
  96.     if (pol)
  97.         atomic_inc(&pol->refcnt);
  98. }
  99.  
  100. extern int __mpol_equal(struct mempolicy *a, struct mempolicy *b);
  101. static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
  102. {
  103.     if (a == b)
  104.         return 1;
  105.     return __mpol_equal(a, b);
  106. }
  107. #define vma_mpol_equal(a,b) mpol_equal(vma_policy(a), vma_policy(b))
  108.  
  109. /* Could later add inheritance of the process policy here. */
  110.  
  111. #define mpol_set_vma_default(vma) ((vma)->vm_policy = NULL)
  112.  
  113. /*
  114.  * Hugetlb policy. i386 hugetlb so far works with node numbers
  115.  * instead of zone lists, so give it special interfaces for now.
  116.  */
  117. extern int mpol_first_node(struct vm_area_struct *vma, unsigned long addr);
  118. extern int mpol_node_valid(int nid, struct vm_area_struct *vma,
  119.             unsigned long addr);
  120.  
  121. /*
  122.  * Tree of shared policies for a shared memory region.
  123.  * Maintain the policies in a pseudo mm that contains vmas. The vmas
  124.  * carry the policy. As a special twist the pseudo mm is indexed in pages, not
  125.  * bytes, so that we can work with shared memory segments bigger than
  126.  * unsigned long.
  127.  */
  128.  
  129. struct sp_node {
  130.     struct rb_node nd;
  131.     unsigned long start, end;
  132.     struct mempolicy *policy;
  133. };
  134.  
  135. struct shared_policy {
  136.     struct rb_root root;
  137.     spinlock_t lock;
  138. };
  139.  
  140. static inline void mpol_shared_policy_init(struct shared_policy *info)
  141. {
  142.     info->root = RB_ROOT;
  143.     spin_lock_init(&info->lock);
  144. }
  145.  
  146. int mpol_set_shared_policy(struct shared_policy *info,
  147.                 struct vm_area_struct *vma,
  148.                 struct mempolicy *new);
  149. void mpol_free_shared_policy(struct shared_policy *p);
  150. struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
  151.                         unsigned long idx);
  152.  
  153. extern void numa_default_policy(void);
  154. extern void numa_policy_init(void);
  155.  
  156. #else
  157.  
  158. struct mempolicy {};
  159.  
  160. static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
  161. {
  162.     return 1;
  163. }
  164. #define vma_mpol_equal(a,b) 1
  165.  
  166. #define mpol_set_vma_default(vma) do {} while(0)
  167.  
  168. static inline void mpol_free(struct mempolicy *p)
  169. {
  170. }
  171.  
  172. static inline void mpol_get(struct mempolicy *pol)
  173. {
  174. }
  175.  
  176. static inline struct mempolicy *mpol_copy(struct mempolicy *old)
  177. {
  178.     return NULL;
  179. }
  180.  
  181. static inline int mpol_first_node(struct vm_area_struct *vma, unsigned long a)
  182. {
  183.     return numa_node_id();
  184. }
  185.  
  186. static inline int
  187. mpol_node_valid(int nid, struct vm_area_struct *vma, unsigned long a)
  188. {
  189.     return 1;
  190. }
  191.  
  192. struct shared_policy {};
  193.  
  194. static inline int mpol_set_shared_policy(struct shared_policy *info,
  195.                     struct vm_area_struct *vma,
  196.                     struct mempolicy *new)
  197. {
  198.     return -EINVAL;
  199. }
  200.  
  201. static inline void mpol_shared_policy_init(struct shared_policy *info)
  202. {
  203. }
  204.  
  205. static inline void mpol_free_shared_policy(struct shared_policy *p)
  206. {
  207. }
  208.  
  209. static inline struct mempolicy *
  210. mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
  211. {
  212.     return NULL;
  213. }
  214.  
  215. #define vma_policy(vma) NULL
  216. #define vma_set_policy(vma, pol) do {} while(0)
  217.  
  218. static inline void numa_policy_init(void)
  219. {
  220. }
  221.  
  222. static inline void numa_default_policy(void)
  223. {
  224. }
  225.  
  226. #endif /* CONFIG_NUMA */
  227. #endif /* __KERNEL__ */
  228.  
  229. #endif
  230.